/**
 * 
 * 
 *  
 *====================================================
 * 文件名称: BaseDaoImpl.java
 * 修订记录：
 * No    日期				作者(操作:具体内容)
 * 1.    2009-6-30			
 *====================================================
 * 类描述：(说明未实现或其它不应生成javadoc的内容)
 * 
 */
package com.devframe.sysbase.dao;

import java.io.Serializable;
import java.math.BigInteger;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.devframe.sys.util.page.PageInfo;



/**
 *<pre><b><font color="blue">BaseDaoImpl</font></b></pre>
 *
 *<pre><b>&nbsp;--基础DAO接口--</b></pre>
 * <pre>
 * 包含Hibernate和JDBC两套接口方法，以及在配置文件中的命名SQL的直接查询操作，也包括对存储过程的查询。
 * 查询参数支持多种形式，如单个参数直接传递，数组方式传递，Map方式传递等。
 * 支持分页查询，分页参数和返回结果为PageInfo类型。
 * <pre>
 * <b>--样例--</b>
 *   BaseDaoImpl obj = new BaseDaoImpl();
 *   obj.setSessionFactory(sessionFactory);
 *   List list = obj.queryForList(hql,params);
 * </pre>
 * JDK版本：JDK1.4
 * @author  <b></b> 
 */
public interface BaseDao {

    /**
     * 返回一个新的session，
     * 从SessionFactoryUtils取得当前线程的session
     * 
     * @return the active Session
     */
    Session getSession();

    /**
     * SessionFactory 注入SessionFactory方法
     * @param sessionFactory sessionFactory
     */
    void setSessionFactory(SessionFactory sessionFactory);

    /**
     * getSessionFactory
     * @return sessionFactory
     */
    SessionFactory getSessionFactory();

    /**
     * 执行hibernate的HQL查询语句返回列表
     * 
     * @param queryStr queryStr
     * @return List
     */
    List queryForList(String queryStr);

    /**
     * 执行HQL查询语句返回列表
     * 
     * @param queryStr queryStr
     * @param params  params
     * @return List
     */
    List queryForList(String queryStr, Map params);

    /**
     * hibernate 分页数据查询
     * 
     * @param hql
     *            需要执行的hql语句
     * @param params
     *            参数MAP
     *            总记录数，为0表示第一页查询，会自动查询总记录数。
     *            自动计算总记录数只适用于简单查询，如对一个对象的查询或者没有分组汇总计算的查询或者记录量很小的查询。
     *            分组汇总查询在HQL中没法生成快速的总数查询语句，只能查询出全部记录计算总记录数，这在记录量大时会带来很大的性能问题。
     *            建议另行计算总数，可以采用更优化的方法进行计算，在查询中传入总记录数值，可以避免重复查询总记录数。
     * @param pageInfo 分页参数:总记录数、分页记录数、当前页码
     * @return PageInfo
     */
    PageInfo queryForPage(String hql, Map params, PageInfo pageInfo);

    /**
     * hibernate 分页查询：
     * 
     * 一般查询语句：如select a from tablea a where conditionExpr order by orderExpr
     * 生成的总数查询语句为 select count(*) from tablea a where conditionExpr
     * 分组汇总查询HQL语句没法生成总数查询语句(因为hql不支持在查询中用子查询)，
     * 只能查询全部记录得到记录数。性能很差应避免使用，此时应通过变通的方法先求出总数然后再进行分页查询。
     * @param hql 查询hql
     * @param params 查询参数
     * @param totalCount 总记录数，为0时自动查询总记录数，否则不再查询总记录数
     * @param pageSize 分页记录数
     * @param pageIndex 页码
     * @param sortField 排序字段
     * @param sortDirect 排序方向
     * @return 分页数据
     * 
     */
    PageInfo queryForPage(String hql, Map params, int totalCount, int pageSize, int pageIndex,String sortField,String sortDirect);

    /**
     * 执行返回一条记录的查询,方便对单个对象查询以及总数合计类的查询
     * @param hql hql
     * @return Object
     * 
     */
    Object queryForObject(String hql);

    /**
     * 执行返回一条记录的查询,方便对单个对象查询以及总数合计类的查询
     * 
     * @param hql
     *            hql语句
     * @param params
     *            Map存储的参数
     * @return Object
     */
    Object queryForObject(String hql, Map params);

    /**
     * 执行hql批量更新语句
     * 
     * @param hql sql
     * @param params 参数，可以为null
     * @return 更新影响的记录数
     */
    int executeUpdate(String hql, Map params);

    /**
     * 执行hql批量更新语句
     * @param hql sql
     * @return 更新影响的记录数
     */
    int executeUpdate(String hql);

    /**
     * 通过命名参数执行JDBC语句查询列表的方法
     * @param queryStr 查询SQL
     * @param params 查询参数
     * @return List
     * 
     */
    List sqlQueryForList(String queryStr, Map params);

    /**
     * 通过JDBC原生SQL查询列表，返回HashMap对象组成的列表
     * 
     * @param queryStr
     *            查询SQL
     * @return List
     * 
     */
    List sqlQueryForList(String queryStr);

    /**
     * 单记录查询,返回字段名为主键的MAP
     * 
     * @param queryStr 查询sql
     * @return Map
     */
    Map sqlQueryForMap(String queryStr);

    /**
     * 单记录查询,返回字段名为主键的MAP
     * 
     * @param queryStr 查询sql
     * @param params 查询参数
     * @return Map
     * 
     */
    Map sqlQueryForMap(String queryStr, Map params);

    /**
     * 单值查询,返回查询结果值
     * 
     * @param queryStr 查询sql
     * @return Map
     */
    String sqlQueryForValue(String queryStr);
    /**
     * @param sql 查询sql
     * @param pageInfo 分页条件
     * @return 查询结果对象分页列表
     * 
     */
    PageInfo sqlQueryForPage(String sql, PageInfo pageInfo);
    /**
     * 单值查询,返回查询结果值
     * 
     * @param queryStr 查询sql
     * @param params 查询参数
     * @return Map
     * 
     */
    String sqlQueryForValue(String queryStr, Map params);
    
    /**
     * 执行JDBC语句分页查询的方法
     * @param sql 查询sql
     * @param totalCount 总记录数
     * @param pageSize 分页记录数
     * @param pageIndex 页码
     * @param sortField 排序字段
     * @param sortDirect 排序方向，asc或者desc，默认asc
     * @return 查询结果对象分页列表
     * 
     */
    PageInfo sqlQueryForPage(String sql, int totalCount, int pageSize, int pageIndex);

    /**
     * @param sql 查询sql
     * @param params 查询参数
     * @param pageInfo 分页条件
     * @return 查询结果对象分页列表
     * 
     */
    PageInfo sqlQueryForPage(String sql, Map params, PageInfo pageInfo);

    /**
     * 执行JDBC语句分页查询的方法，参数使用命名参数方式传递，放在一个MAP对象中
     * @param sql 查询sql
     * @param params 查询参数
     * @param totalCount 总记录数
     * @param pageSize 分页记录数
     * @param pageIndex 页码
     * @return 查询结果对象分页列表
     * 
     */
    PageInfo sqlQueryForPage(String sql, Map params, int totalCount, int pageSize, int pageIndex,String sortField,String sortDirect);

    /**
     * 执行JDBC SQL更新语句,也可以执行不需要返回值的过程
     * 
     * @param sql sql
     * @param params 参数，可以为null
     * @return 更新影响的记录数
     */
    int executeSqlUpdate(String sql, Map params);

    /**
     * 执行JDBC SQL更新语句,也可以执行不需要返回值的过程
     * @param sql sql
     * @return 更新影响的记录数
     */
    int executeSqlUpdate(String sql);

    /**
     * 根据对象类型和ID查询对象
     * @param refClass Hibernate映射类
     * @param key 主键值
     * @return Hibernate对象
     * 
     */
    Object get(Class refClass, Serializable key);

    /**
     * 
     * 根据对象类型和ID 用load方法查找对象
     * @param refClass Hibernate映射类
     * @param key 主键值
     * @return Hibernate对象
     * 
     */
    Object load(Class refClass, Serializable key);

    /**
     * 查询一个对象的所有记录
     * @param refClass Hibernate映射类
     * @return List所有对象列表
     * 
     */
    List findAll(Class refClass);

    /**
     * 
     * 从配置文件中获取命名sql对象
     * @param queryName
     *            the name of a query defined externally
     * @return Query
     */
    Query getNamedQuery(String queryName);

    /**
     * getNamedQuerySql
     * 从配置文件中获取命名sql对象的SQL，用于将SQL独立在java类之外。
     * @param name 命名SQL名字
     * @return sql脚本
     * 
     */
    String getNamedQuerySql(String name);

    /**
     * 执行配置文件中的命名sql并指定唯一参数
     * SQL中通过?代表参数
     * @param name
     *            the name of a query defined externally
     * @param param
     *            the only parameter to set
     * @return List
     */
    List namedQueryForList(String name, Serializable param);

    /**
     * 执行配置文件中的命名sql并指定参数数组
     * SQL中通过?代表参数
     * @param name
     *            the name of a query defined externally
     * @param params
     *            the parameter array
     * @return List
     */
    List namedQueryForList(String name, Serializable[] params);

    /**
     * 执行配置文件中的命名sql并指定参数Map
     * SQL中通过:paramName形式对参数进行命名
     * @param name
     *            the name of a query defined externally
     * @param params
     *            the parameter Map
     * @return Query
     */
    List namedQueryForList(String name, Map params);

    /**
     * create a query.
     * 通过hql创建Query对象
     * @param hql
     *            a query expressed in Hibernate's query language
     * @return Query
     */
    Query getQuery(String hql);

    /**
     * 通过hql创建Query对象，指定唯一参数
     * 
     * @param hql
     *            a query expressed in Hibernate's query language
     * @param param
     *            the first parameter to set
     * @return Query
     */
    Query getQuery(String hql, Serializable param);

    /**
     * Create a query.
     * 通过hql创建Query对象，指定参数数组
     * @param hql
     *            a query expressed in Hibernate's query language
     * @param params
     *            the parameter array
     * @return Query
     */
    Query getQuery(String hql, Serializable[] params);

    /**
     * Create a query.
     * 通过hql创建Query对象，指定参数Map
     * 加强版的getQuery,可以处理in(:paramName)格式的参数，
     * 此时参数用实现iterator接口或者Collection接口的类型传入，如List;也可以用数组传入，如String[]
     * @param hql hibernate query statement
     * @param params 参数Map
     * @return  Query
     * 
     */
    Query getQuery(String hql, Map params);

    /**
     * Hibernate 保存新增对象
     * @param obj 新增对象
     * @return 主键值
     * 
     */
    Serializable save(final Object obj);

    /**
     * Hibernate 批量保存新增对象
     * save
     * @param objs 新增对象集合
     * @return 记录数
     * 
     */
    int save(final Collection objs);

    /**
     * Hibernate 保存对象修改
     * @param obj 修改对象
     * 
     */
    void update(final Object obj);

    /**
     * Hibernate 批量保存对象修改
     * @param objs 修改对象集合
     * 
     */
    void update(final Collection objs);

    /**
     * Hibernate 删除query查询的所有记录
     * @param query Query对象
     * @return 删除记录数
     */
    int delete(final Query query);

    /**
     * Hibernate 删除对象
     * @param obj 要删除的对象
     * 
     */
    void delete(final Object obj);
    
    /**
     * delete 批量删除
     * @param refClass Po类
     * @param key 主键数组
     * 
     */
    void delete(Class refClass, Serializable[] key);

    /**
     * Hibernate 批量删除
     * 
     * @param objs 要删除的记录集合
     * 
     */
    void delete(final Collection objs);

    /**
     * Hibernate 刷新对象状态
     * @param obj 要刷新对象
     */
    void refresh(Object obj);

//    /**
//     * 执行存储过程
//     * 示例：
//     * Object inParams = new Object[2];
//     * inParams[0] = value1;
//     * inParams[1] = value2;
//     * int[] outParamTypes = new int[2];
//     * outParamTypes[0] = java.sql.Types.NUMERIC;
//     * outParamTypes[1] = java.sql.Types.NUMERIC;
//     * 
//     * Map result = baseDao.executeJDBCProc("{call procName(?,?,?,?)}",inParams,outParamTypes);
//     * Object result0 = result.get(0);
//     * Object result1 = result.get(1);
//     * @param procName 存储过程调用语句
//     * @param inParams
//     *            key 为参数索引，从1开始。value为参数值
//     * @param outParamTypes 为返回值类型数组 
//     * @return 返回参数，
//     * key为返回值顺序号，从0开始
//     * value为过程返回值，如果返回值为结果集则封装成HashMap组成的List
//     * @throws Exception Exception
//     */
//    Map executeJDBCProc(String procName, Object[] inParams, int[] outParamTypes) throws Exception;
//    
//    /**
//     * 2011-11-30 重载前一个方法,增加输入参数类型信息,防止特定WAS出现问题
//     * @param procName
//     * @param inParams
//     * @param inTypes
//     * @param outParamTypes
//     * @return
//     * @throws Exception
//     */
//    public Map executeJDBCProc(String procName, Object[] inParams,int[]inTypes, int[] outParamTypes)throws Exception;;
//
//    /**
//     * 常用过程调用，
//     * 返回参数为code,message两个 
//     * 返回Map中代码为code,消息为message
//     * 
//     * @param procName 存储过程
//     * @param inParams 传入参数
//     * @return 返回存储过程返回信息
//     * @throws Exception Exception
//     * 
//     */
//    Map executeNormalJDBCProc(String procName, Object[] inParams) throws Exception;
//
//    /**
//     * executeJDBCFunc
//     * 简单函数调用，不支持通过out参数返回值。
//     * @param funcName 函数名,可以只写函数名
//     * @param inParams 输入参数
//     * @param returnType 返回值类型
//     * @return 返回值
//     * @throws Exception Exception
//     * 
//     */
//    Object executeJDBCFunc(String funcName, Object[] inParams, int returnType) throws Exception;
    
    /**
     * getSequenceValue
     * @param sequenceName 序列号
     * @return 序列值
     * 
     */
    BigInteger getSequenceValue(String sequenceName);
    

    /**
     * 获取ORACEL的当前时间字符串
     * @return
     */
    String getOracleCurrentTimeString();

}